home *** CD-ROM | disk | FTP | other *** search
/ CD/PC Actual 31 / PC Actual CD 31.iso / dists / SRC / SLIBEXEC.AA / SLIBEXEC / libexec / bootpd / dovend.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-02-22  |  10.0 KB  |  415 lines
  1. /*
  2.  * dovend.c : Inserts all but the first few vendor options.
  3.  *
  4.  *    $Id: dovend.c,v 1.4 1997/02/22 14:21:03 peter Exp $
  5.  */
  6.  
  7. #include <sys/types.h>
  8.  
  9. #include <netinet/in.h>
  10. #include <arpa/inet.h>            /* inet_ntoa */
  11.  
  12. #include <stdlib.h>
  13. #include <stdio.h>
  14. #include <string.h>
  15. #include <errno.h>
  16. #include <syslog.h>
  17.  
  18. #ifndef USE_BFUNCS
  19. # include <memory.h>
  20. /* Yes, memcpy is OK here (no overlapped copies). */
  21. # define bcopy(a,b,c)    memcpy(b,a,c)
  22. # define bzero(p,l)      memset(p,0,l)
  23. # define bcmp(a,b,c)     memcmp(a,b,c)
  24. # define index           strchr
  25. #endif
  26.  
  27. #include "bootp.h"
  28. #include "bootpd.h"
  29. #include "report.h"
  30. #include "dovend.h"
  31.  
  32. #ifdef    __STDC__
  33. #define P(args) args
  34. #else
  35. #define P(args) ()
  36. #endif
  37.  
  38. PRIVATE int insert_generic P((struct shared_bindata *, byte **, int *));
  39.  
  40. /*
  41.  * Insert the 2nd part of the options into an option buffer.
  42.  * Return amount of space used.
  43.  *
  44.  * This inserts everything EXCEPT:
  45.  *   magic cookie, subnet mask, gateway, bootsize, extension file
  46.  * Those are handled separately (in bootpd.c) to allow this function
  47.  * to be shared between bootpd and bootpef.
  48.  *
  49.  * When an "extension file" is in use, the options inserted by
  50.  * this function go into the exten_file, not the bootp response.
  51.  */
  52.  
  53. int
  54. dovend_rfc1497(hp, buf, len)
  55.     struct host *hp;
  56.     byte *buf;
  57.     int len;
  58. {
  59.     int bytesleft = len;
  60.     byte *vp = buf;
  61.  
  62.     static char noroom[] = "%s: No room for \"%s\" option";
  63. #define    NEED(LEN, MSG) do                       \
  64.         if (bytesleft < (LEN)) {                 \
  65.             report(LOG_NOTICE, noroom,          \
  66.                    hp->hostname->string, MSG);  \
  67.             return (vp - buf);                  \
  68.         } while (0)
  69.  
  70.     /*
  71.      * Note that the following have already been inserted:
  72.      *   magic_cookie, subnet_mask, gateway, bootsize
  73.      *
  74.      * The remaining options are inserted in order of importance.
  75.      * (Of course the importance of each is a matter of opinion.)
  76.      * The option insertion order should probably be configurable.
  77.      *
  78.      * This is the order used in the NetBSD version.  Can anyone
  79.      * explain why the time_offset and swap_server are first?
  80.      * Also, why is the hostname so far down the list?  -gwr
  81.      */
  82.  
  83.     if (hp->flags.time_offset) {
  84.         NEED(6, "to");
  85.         *vp++ = TAG_TIME_OFFSET;/* -1 byte  */
  86.         *vp++ = 4;                /* -1 byte  */
  87.         insert_u_long(htonl(hp->time_offset), &vp);    /* -4 bytes */
  88.         bytesleft -= 6;
  89.     }
  90.     /*
  91.      * swap server, root path, dump path
  92.      */
  93.     if (hp->flags.swap_server) {
  94.         NEED(6, "sw");
  95.         /* There is just one SWAP_SERVER, so it is not an iplist. */
  96.         *vp++ = TAG_SWAP_SERVER;/* -1 byte  */
  97.         *vp++ = 4;                /* -1 byte  */
  98.         insert_u_long(hp->swap_server.s_addr, &vp);    /* -4 bytes */
  99.         bytesleft -= 6;            /* Fix real count */
  100.     }
  101.     if (hp->flags.root_path) {
  102.         /*
  103.          * Check for room for root_path.  Add 2 to account for
  104.          * TAG_ROOT_PATH and length.
  105.          */
  106.         len = strlen(hp->root_path->string);
  107.         NEED((len + 2), "rp");
  108.         *vp++ = TAG_ROOT_PATH;
  109.         *vp++ = (byte) (len & 0xFF);
  110.         bcopy(hp->root_path->string, vp, len);
  111.         vp += len;
  112.         bytesleft -= len + 2;
  113.     }
  114.     if (hp->flags.dump_file) {
  115.         /*
  116.          * Check for room for dump_file.  Add 2 to account for
  117.          * TAG_DUMP_FILE and length.
  118.          */
  119.         len = strlen(hp->dump_file->string);
  120.         NEED((len + 2), "df");
  121.         *vp++ = TAG_DUMP_FILE;
  122.         *vp++ = (byte) (len & 0xFF);
  123.         bcopy(hp->dump_file->string, vp, len);
  124.         vp += len;
  125.         bytesleft -= len + 2;
  126.     }
  127.     /*
  128.      * DNS server and domain
  129.      */
  130.     if (hp->flags.domain_server) {
  131.         if (insert_ip(TAG_DOMAIN_SERVER,
  132.                       hp->domain_server,
  133.                       &vp, &bytesleft))
  134.             NEED(8, "ds");
  135.     }
  136.     if (hp->flags.domain_name) {
  137.         /*
  138.          * Check for room for domain_name.  Add 2 to account for
  139.          * TAG_DOMAIN_NAME and length.
  140.          */
  141.         len = strlen(hp->domain_name->string);
  142.         NEED((len + 2), "dn");
  143.         *vp++ = TAG_DOMAIN_NAME;
  144.         *vp++ = (byte) (len & 0xFF);
  145.         bcopy(hp->domain_name->string, vp, len);
  146.         vp += len;
  147.         bytesleft -= len + 2;
  148.     }
  149.     /*
  150.      * NIS (YP) server and domain
  151.      */
  152.     if (hp->flags.nis_server) {
  153.         if (insert_ip(TAG_NIS_SERVER,
  154.                       hp->nis_server,
  155.                       &vp, &bytesleft))
  156.             NEED(8, "ds");
  157.     }
  158.     if (hp->flags.nis_domain) {
  159.         /*
  160.          * Check for room for nis_domain.  Add 2 to account for
  161.          * TAG_NIS_DOMAIN and length.
  162.          */
  163.         len = strlen(hp->nis_domain->string);
  164.         NEED((len + 2), "dn");
  165.         *vp++ = TAG_NIS_DOMAIN;
  166.         *vp++ = (byte) (len & 0xFF);
  167.         bcopy(hp->nis_domain->string, vp, len);
  168.         vp += len;
  169.         bytesleft -= len + 2;
  170.     }
  171.     /* IEN 116 name server */
  172.     if (hp->flags.name_server) {
  173.         if (insert_ip(TAG_NAME_SERVER,
  174.                       hp->name_server,
  175.                       &vp, &bytesleft))
  176.             NEED(8, "ns");
  177.     }
  178.     if (hp->flags.rlp_server) {
  179.         if (insert_ip(TAG_RLP_SERVER,
  180.                       hp->rlp_server,
  181.                       &vp, &bytesleft))
  182.             NEED(8, "rl");
  183.     }
  184.     /* Time server (RFC 868) */
  185.     if (hp->flags.time_server) {
  186.         if (insert_ip(TAG_TIME_SERVER,
  187.                       hp->time_server,
  188.                       &vp, &bytesleft))
  189.             NEED(8, "ts");
  190.     }
  191.     /* NTP (time) Server (RFC 1129) */
  192.     if (hp->flags.ntp_server) {
  193.         if (insert_ip(TAG_NTP_SERVER,
  194.                       hp->ntp_server,
  195.                       &vp, &bytesleft))
  196.             NEED(8, "ts");
  197.     }
  198.     /*
  199.      * I wonder:  If the hostname were "promoted" into the BOOTP
  200.      * response part, might these "extension" files possibly be
  201.      * shared between several clients?
  202.      *
  203.      * Also, why not just use longer BOOTP packets with all the
  204.      * additional length used as option data.  This bootpd version
  205.      * already supports that feature by replying with the same
  206.      * packet length as the client request packet. -gwr
  207.      */
  208.     if (hp->flags.name_switch && hp->flags.send_name) {
  209.         /*
  210.          * Check for room for hostname.  Add 2 to account for
  211.          * TAG_HOST_NAME and length.
  212.          */
  213.         len = strlen(hp->hostname->string);
  214. #if 0
  215.         /*
  216.          * XXX - Too much magic.  The user can always set the hostname
  217.          * to the short version in the bootptab file. -gwr
  218.          */
  219.         if ((len + 2) > bytesleft) {
  220.             /*
  221.              * Not enough room for full (domain-qualified) hostname, try
  222.              * stripping it down to just the first field (host).
  223.              */
  224.             char *tmpstr = hp->hostname->string;
  225.             len = 0;
  226.             while (*tmpstr && (*tmpstr != '.')) {
  227.                 tmpstr++;
  228.                 len++;
  229.             }
  230.         }
  231. #endif
  232.         NEED((len + 2), "hn");
  233.         *vp++ = TAG_HOST_NAME;
  234.         *vp++ = (byte) (len & 0xFF);
  235.         bcopy(hp->hostname->string, vp, len);
  236.         vp += len;
  237.         bytesleft -= len + 2;
  238.     }
  239.     /*
  240.      * The rest of these are less important, so they go last.
  241.      */
  242.     if (hp->flags.lpr_server) {
  243.         if (insert_ip(TAG_LPR_SERVER,
  244.                       hp->lpr_server,
  245.                       &vp, &bytesleft))
  246.             NEED(8, "lp");
  247.     }
  248.     if (hp->flags.cookie_server) {
  249.         if (insert_ip(TAG_COOKIE_SERVER,
  250.                       hp->cookie_server,
  251.                       &vp, &bytesleft))
  252.             NEED(8, "cs");
  253.     }
  254.     if (hp->flags.log_server) {
  255.         if (insert_ip(TAG_LOG_SERVER,
  256.                       hp->log_server,
  257.                       &vp, &bytesleft))
  258.             NEED(8, "lg");
  259.     }
  260.     /*
  261.      * XXX - Add new tags here (to insert options)
  262.      */
  263.     if (hp->flags.generic) {
  264.         if (insert_generic(hp->generic, &vp, &bytesleft))
  265.             NEED(64, "(generic)");
  266.     }
  267.     /*
  268.      * The end marker is inserted by the caller.
  269.      */
  270.     return (vp - buf);
  271. #undef    NEED
  272. }                                /* dovend_rfc1497 */
  273.  
  274.  
  275.  
  276. /*
  277.  * Insert a tag value, a length value, and a list of IP addresses into the
  278.  * memory buffer indirectly pointed to by "dest".  "tag" is the RFC1048 tag
  279.  * number to use, "iplist" is a pointer to a list of IP addresses
  280.  * (struct in_addr_list), and "bytesleft" points to an integer which
  281.  * indicates the size of the "dest" buffer.
  282.  *
  283.  * Return zero if everything fits.
  284.  *
  285.  * This is used to fill the vendor-specific area of a bootp packet in
  286.  * conformance to RFC1048.
  287.  */
  288.  
  289. int
  290. insert_ip(tag, iplist, dest, bytesleft)
  291.     byte tag;
  292.     struct in_addr_list *iplist;
  293.     byte **dest;
  294.     int *bytesleft;
  295. {
  296.     struct in_addr *addrptr;
  297.     unsigned addrcount = 1;
  298.     byte *d;
  299.  
  300.     if (iplist == NULL)
  301.         return (0);
  302.  
  303.     if (*bytesleft >= 6) {
  304.         d = *dest;                /* Save pointer for later */
  305.         **dest = tag;
  306.         (*dest) += 2;
  307.         (*bytesleft) -= 2;        /* Account for tag and length */
  308.         addrptr = iplist->addr;
  309.         addrcount = iplist->addrcount;
  310.         while ((*bytesleft >= 4) && (addrcount > 0)) {
  311.             insert_u_long(addrptr->s_addr, dest);
  312.             addrptr++;
  313.             addrcount--;
  314.             (*bytesleft) -= 4;    /* Four bytes per address */
  315.         }
  316.         d[1] = (byte) ((*dest - d - 2) & 0xFF);
  317.     }
  318.     return (addrcount);
  319. }
  320.  
  321.  
  322.  
  323. /*
  324.  * Insert generic data into a bootp packet.  The data is assumed to already
  325.  * be in RFC1048 format.  It is inserted using a first-fit algorithm which
  326.  * attempts to insert as many tags as possible.  Tags and data which are
  327.  * too large to fit are skipped; any remaining tags are tried until they
  328.  * have all been exhausted.
  329.  * Return zero if everything fits.
  330.  */
  331.  
  332. static int
  333. insert_generic(gendata, buff, bytesleft)
  334.     struct shared_bindata *gendata;
  335.     byte **buff;
  336.     int *bytesleft;
  337. {
  338.     byte *srcptr;
  339.     int length, numbytes;
  340.     int skipped = 0;
  341.  
  342.     if (gendata == NULL)
  343.         return (0);
  344.  
  345.     srcptr = gendata->data;
  346.     length = gendata->length;
  347.     while ((length > 0) && (*bytesleft > 0)) {
  348.         switch (*srcptr) {
  349.         case TAG_END:
  350.             length = 0;            /* Force an exit on next iteration */
  351.             break;
  352.         case TAG_PAD:
  353.             *(*buff)++ = *srcptr++;
  354.             (*bytesleft)--;
  355.             length--;
  356.             break;
  357.         default:
  358.             numbytes = srcptr[1] + 2;
  359.             if (*bytesleft < numbytes)
  360.                 skipped += numbytes;
  361.             else {
  362.                 bcopy(srcptr, *buff, numbytes);
  363.                 (*buff) += numbytes;
  364.                 (*bytesleft) -= numbytes;
  365.             }
  366.             srcptr += numbytes;
  367.             length -= numbytes;
  368.             break;
  369.         }
  370.     } /* while */
  371.     return (skipped);
  372. }
  373.  
  374. /*
  375.  * Insert the unsigned long "value" into memory starting at the byte
  376.  * pointed to by the byte pointer (*dest).  (*dest) is updated to
  377.  * point to the next available byte.
  378.  *
  379.  * Since it is desirable to internally store network addresses in network
  380.  * byte order (in struct in_addr's), this routine expects longs to be
  381.  * passed in network byte order.
  382.  *
  383.  * However, due to the nature of the main algorithm, the long must be in
  384.  * host byte order, thus necessitating the use of ntohl() first.
  385.  */
  386.  
  387. void
  388. insert_u_long(value, dest)
  389.     u_int32 value;
  390.     byte **dest;
  391. {
  392.     byte *temp;
  393.     int n;
  394.  
  395.     value = ntohl(value);        /* Must use host byte order here */
  396.     temp = (*dest += 4);
  397.     for (n = 4; n > 0; n--) {
  398.         *--temp = (byte) (value & 0xFF);
  399.         value >>= 8;
  400.     }
  401.     /* Final result is network byte order */
  402. }
  403.  
  404. /*
  405.  * Local Variables:
  406.  * tab-width: 4
  407.  * c-indent-level: 4
  408.  * c-argdecl-indent: 4
  409.  * c-continued-statement-offset: 4
  410.  * c-continued-brace-offset: -4
  411.  * c-label-offset: -4
  412.  * c-brace-offset: 0
  413.  * End:
  414.  */
  415.